home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-05 / octnet.zip / NETTEST.C < prev    next >
C/C++ Source or Header  |  1989-12-30  |  27KB  |  741 lines
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <dos.h>
  5. #include <mem.h>
  6. #include <bios.h>
  7. #include <conio.h>
  8. #include <string.h>
  9. #include <process.h>
  10. #include <netbios.h>
  11.  
  12. #define  MSG_SIZE  1001
  13.  
  14. /* - - - - - - - - - - - - - - - - - - - - - - - */
  15.  
  16. char            message_out[MSG_SIZE];
  17. char            message_in [MSG_SIZE];
  18. char            string     [MSG_SIZE];
  19. char            string2    [MSG_SIZE];
  20. char            localname  [17];
  21. char            remotename [17];
  22. unsigned char   lsn;
  23. unsigned char   name_number;
  24. int             choice;
  25. int             x;
  26. int             cursor_x;
  27. int             cursor_y;
  28.  
  29. /* - - - - - - - - - - - - - - - - - - - - - - - */
  30.  
  31. unsigned            ncb_segments[10];
  32. unsigned            ncb_offsets [10];
  33. unsigned volatile   ncb_head  = 0;
  34. unsigned            ncb_tail  = 0;
  35.  
  36. /* - - - - - - - - - - - - - - - - - - - - - - - */
  37.  
  38. NCB     reset_ncb;
  39. NCB     adapter_status_ncb;
  40. NCB     session_status_ncb;
  41. NCB     call_ncb;
  42. NCB     listen_ncb;
  43. NCB     add_name_ncb;
  44. NCB     add_group_name_ncb;
  45. NCB     delete_name_ncb;
  46. NCB     send_ncb;
  47. NCB     receive_ncb;
  48. NCB     receive_any_ncb;
  49. NCB     hangup_ncb;
  50. NCB     temp_ncb;
  51.  
  52. /* - - - - - - - - - - - - - - - - - - - - - - - */
  53.  
  54. typedef struct {
  55.         unsigned char   card_id[6];
  56.         unsigned char   release_level;
  57.         unsigned char   reserved1;
  58.         unsigned char   type_of_adapter;
  59.         unsigned char   old_or_new_parameters;
  60.         unsigned int    reporting_period_minutes;
  61.  
  62.         unsigned int    frame_reject_recvd_count;
  63.         unsigned int    frame_reject_sent_count;
  64.         unsigned int    recvd_I_frame_errors;
  65.  
  66.         unsigned int    unsuccessful_transmissions;
  67.         unsigned long   good_transmissions;
  68.         unsigned long   good_receptions;
  69.         unsigned int    retransmissions;
  70.         unsigned int    exhausted_resource_count;
  71.         unsigned int    t1_timer_expired_count;
  72.         unsigned int    ti_timer_expired_count;
  73.         char            reserved2[4];
  74.         unsigned int    available_ncbs;
  75.         unsigned int    max_ncbs_configured;
  76.         unsigned int    max_ncbs_possible;
  77.         unsigned int    buffer_or_station_busy_count;
  78.         unsigned int    max_datagram_size;
  79.         unsigned int    pending_sessions;
  80.         unsigned int    max_sessions_configured;
  81.         unsigned int    max_sessions_possible;
  82.         unsigned int    max_frame_size;
  83.         int             name_count;
  84.         struct {
  85.             char            tbl_name[16];
  86.             unsigned char   tbl_name_number;
  87.             unsigned char   tbl_name_status;
  88.             } name_table[20];
  89.         }
  90.         ADAPTER_DATA;
  91.  
  92. typedef struct {
  93.          unsigned char  lsn;
  94.          unsigned char  state;
  95.          char           local_name[16];
  96.          char           remote_name[16];
  97.          unsigned char  recv_count;
  98.          unsigned char  send_count;
  99.          }
  100.         A_SESSION;
  101.  
  102. typedef struct {
  103.         unsigned char  name_num;
  104.         unsigned char  session_count;
  105.         unsigned char  junk1;
  106.         unsigned char  junk2;
  107.         A_SESSION      session_data[40];
  108.         }
  109.         STATUS_INFO;
  110.  
  111. ADAPTER_DATA    adapter_data;
  112. STATUS_INFO     session_info;
  113.  
  114. /* - - - - - - - - - - - - - - - - - - - - - - - */
  115.  
  116. unsigned        es_reg, bx_reg;
  117. void interrupt  (*int_5C_vector)(void);
  118. char            screen_save[4000];
  119.  
  120. char    *state_msg [7] = {
  121.         "                 ",
  122.         "LISTEN pending",
  123.         "CALL pending",
  124.         "Active session",
  125.         "HANG UP pending",
  126.         "HANG UP complete",
  127.         "Session abort"
  128.         };
  129.  
  130. int     name_type;
  131. char    *name_type_msg [2] = {
  132.         "Unique name",
  133.         "Group name "
  134.         };
  135.  
  136. int     name_status;
  137. char    *name_status_msg [8] = {
  138.         "Reg. in progress   ",
  139.         "                   ",
  140.         "                   ",
  141.         "                   ",
  142.         "Registered         ",
  143.         "De-registered      ",
  144.         "Dupl detected      ",
  145.         "Dupl; dereg pend.  "
  146.         };
  147.  
  148. unsigned char    *box[18] = {
  149.    "┌[NetTest POST results]───────────────────────────────────────────┐",
  150.    "│                                                                 │",
  151.    "│                                                                 │",
  152.    "│                                                                 │",
  153.    "│                                                                 │",
  154.    "│                                                                 │",
  155.    "│                                                                 │",
  156.    "│                                                                 │",
  157.    "│                                                                 │",
  158.    "│                                                                 │",
  159.    "│                                                                 │",
  160.    "│                                                                 │",
  161.    "│                                                                 │",
  162.    "│                                                                 │",
  163.    "│                                                                 │",
  164.    "│                                                                 │",
  165.    "│                                                                 │",
  166.    "└─────────────────────────────────────────────────────────────────┘"
  167.         };
  168.  
  169.  
  170. /* - - - - - - - - - - - - - - - - - - - - - - - */
  171.  
  172. void    NetBios(NCB far *ncb_ptr)
  173.         {
  174.         _ES    = FP_SEG(ncb_ptr);
  175.         _BX    = FP_OFF(ncb_ptr);
  176.         _AX    = 0x0100;
  177.         geninterrupt(0x5c);
  178.         }
  179.  
  180. /* - - - - - - - - - - - - - - - - - - - - - - - */
  181.  
  182. void    expand_to_16_chars(char *name)
  183.         {
  184.         char *p;
  185.         char tmp[17];
  186.         int  i;
  187.  
  188.         memset(tmp, ' ', 15);
  189.         p = name;
  190.         i = 0;
  191.         while (i < 15 && *p)
  192.             {
  193.             tmp[i] = *p;
  194.             i++;
  195.             p++;
  196.             }
  197.         tmp[15] = '\0';
  198.         strcpy(name, tmp);
  199.         }
  200.  
  201. /* - - - - - - - - - - - - - - - - - - - - - - - */
  202.  
  203. void    show_traffic_and_errors(void)
  204.         {
  205.         gotoxy(1, 6);
  206.         cprintf("   Release level: %2.2X ", 
  207.                     (int) adapter_data.release_level);
  208.         gotoxy(1, 8);
  209.         cprintf("    Adapter type: %2.2X ", 
  210.                     (int) adapter_data.type_of_adapter);
  211.         gotoxy(1, 10);
  212.         cprintf("   Old/new parms: %2.2X ", 
  213.                     (int) adapter_data.old_or_new_parameters);
  214.         gotoxy(15, 16);
  215.         cprintf("(Press a key)");
  216.         bioskey(0);
  217.         clrscr();
  218.  
  219.         gotoxy(1, 6);
  220.         cprintf("   Reporting period (mins): %6u ", 
  221.                     adapter_data.reporting_period_minutes);
  222.         gotoxy(1, 8);
  223.         cprintf(" Frame rejections received: %6u ", 
  224.                     adapter_data.frame_reject_recvd_count);
  225.         gotoxy(1, 10);
  226.         cprintf("     Frame rejections sent: %6u ", 
  227.                     adapter_data.frame_reject_sent_count);
  228.         gotoxy(1, 12);
  229.         cprintf("   Received I-frame errors: %6u ", 
  230.                     adapter_data.recvd_I_frame_errors);
  231.         gotoxy(1, 14);
  232.         cprintf("Unsuccessful transmissions: %6u ", 
  233.                     adapter_data.unsuccessful_transmissions);
  234.         gotoxy(15, 16);
  235.         cprintf("(Press a key)");
  236.         bioskey(0);
  237.         clrscr();
  238.  
  239.         gotoxy(1, 6);
  240.         cprintf("Good transmissions: %10lu ", 
  241.                     adapter_data.good_transmissions);
  242.         gotoxy(1, 8);
  243.         cprintf("   Good receptions: %10lu ", 
  244.                     adapter_data.good_receptions);
  245.         gotoxy(15, 16);
  246.         cprintf("(Press a key)");
  247.         bioskey(0);
  248.         clrscr();
  249.  
  250.         gotoxy(1, 6);
  251.         cprintf("        Retransmissions: %6u ", 
  252.                     adapter_data.retransmissions);
  253.         gotoxy(1, 7);
  254.         cprintf("    Exhausted resources: %6u ", 
  255.                     adapter_data.exhausted_resource_count);
  256.         gotoxy(1, 8);
  257.         cprintf("        Available NCB's: %6u ", 
  258.                     adapter_data.available_ncbs);
  259.         gotoxy(1, 9);
  260.         cprintf("   Max configured NCB's: %6u ", 
  261.                     adapter_data.max_ncbs_configured);
  262.         gotoxy(1, 10);
  263.         cprintf("     Max possible NCB's: %6u ", 
  264.                     adapter_data.max_ncbs_possible);
  265.         gotoxy(1, 11);
  266.         cprintf("       Pending sessions: %6u ", 
  267.                     adapter_data.pending_sessions);
  268.         gotoxy(1, 12);
  269.         cprintf("Max configured sessions: %6u ", 
  270.                     adapter_data.max_sessions_configured);
  271.         gotoxy(1, 13);
  272.         cprintf("  Max possible sessions: %6u ", 
  273.                     adapter_data.max_sessions_possible);
  274.         gotoxy(1, 14);
  275.         cprintf("         Max frame size: %6u ", 
  276.                     adapter_data.max_frame_size);
  277.         gotoxy(15, 16);
  278.         cprintf("(Press a key)");
  279.         bioskey(0);
  280.         clrscr();
  281.         }
  282.  
  283. /* - - - - - - - - - - - - - - - - - - - - - - - */
  284.  
  285. void    report_result(void)
  286.         {
  287.         int i, j;
  288.  
  289.         gettext(1, 1, 80, 25, screen_save);
  290.         cursor_x = wherex();
  291.         cursor_y = wherey();
  292.         for (i=0; i<18; i++)
  293.             {
  294.             gotoxy(5, i+1);
  295.             cprintf("%s", box[i]);
  296.             }
  297.         window(6, 2, 70, 17);
  298.  
  299.         movedata(ncb_segments[ncb_tail], ncb_offsets[ncb_tail],
  300.                  FP_SEG(&temp_ncb), FP_OFF(&temp_ncb),
  301.                  sizeof(NCB));
  302.         ncb_tail++;
  303.         if (ncb_tail == 10)
  304.             ncb_tail = 0;
  305.  
  306.         if (temp_ncb.NCB_LENGTH == MSG_SIZE - 1)
  307.             temp_ncb.NCB_LENGTH = 0;
  308.  
  309.         if (temp_ncb.NCB_LENGTH >  320)
  310.             temp_ncb.NCB_LENGTH = 320;
  311.  
  312.         switch (temp_ncb.NCB_COMMAND)
  313.             {
  314.             case RESET         : {strcpy(string, "RESET ADAPTER"); break;}
  315.             case STATUS        : {strcpy(string, "ADAPTER STATUS");break;}
  316.             case ADD_NAME      : {strcpy(string, "ADD NAME");      break;}
  317.             case ADD_GROUP_NAME: {strcpy(string, "ADD GRP NAME");  break;}
  318.             case DELETE_NAME   : {strcpy(string, "DELETE NAME");   break;}
  319.             case LISTEN        : {strcpy(string, "LISTEN");        break;}
  320.             case CALL          : {strcpy(string, "CALL");          break;}
  321.             case HANG_UP       : {strcpy(string, "HANG UP");       break;}
  322.             case SEND          : {strcpy(string, "SEND");          break;}
  323.             case RECEIVE       : {strcpy(string, "RECEIVE");       break;}
  324.             case RECEIVE_ANY   : {strcpy(string, "RECEIVE ANY");   break;}
  325.             case SESSION_STATUS: {strcpy(string, "SESSION STATUS");break;}
  326.             default            : {strcpy(string, "<unknown>");     break;}
  327.             }
  328.  
  329.         gotoxy(1, 1);
  330.         cprintf("Command: %s", string);
  331.  
  332.         if (temp_ncb.NCB_RETCODE <= 0x26)
  333.             strcpy(string, net_error_message[temp_ncb.NCB_RETCODE]);
  334.         else
  335.         if (temp_ncb.NCB_RETCODE == 0xff)
  336.             strcpy(string, "command pending");
  337.         else
  338.             strcpy(string, "adapter malfunction");
  339.  
  340.         if (temp_ncb.NCB_CMD_CPLT <= 0x26)
  341.             strcpy(string2, net_error_message[temp_ncb.NCB_CMD_CPLT]);
  342.         else
  343.         if (temp_ncb.NCB_CMD_CPLT == 0xff)
  344.             strcpy(string2, "command pending");
  345.         else
  346.             strcpy(string2, "adapter malfunction");
  347.  
  348.         gotoxy(1, 2);
  349.         cprintf("Immed: %s.  Final: %s.", string, string2);
  350.  
  351.         if (temp_ncb.NCB_RETCODE > 0 || temp_ncb.NCB_CMD_CPLT > 0)
  352.             goto report_exit;
  353.  
  354.  
  355.  
  356.         if (temp_ncb.NCB_COMMAND == STATUS)
  357.             {
  358.             gotoxy(1, 4);
  359.             cprintf("Card ID (hex): ");
  360.             for (i=0; i<6; i++)
  361.                 cprintf("%2.2X ", (int) adapter_data.card_id[i]);
  362.             show_traffic_and_errors();
  363.             gotoxy(1, 14);
  364.             cprintf("Local name table items: %d", adapter_data.name_count);
  365.             gotoxy(15, 16);
  366.             cprintf("(Press a key)");
  367.             bioskey(0);
  368.             if (adapter_data.name_count == 0) goto report_exit;
  369.             clrscr();
  370.             for (i=0, j=2; i<adapter_data.name_count; i++)
  371.                 {
  372.                 adapter_data.name_table[i].tbl_name[15] = '\0';
  373.                 name_status = (int) adapter_data.name_table[i].tbl_name_status;
  374.                 name_status &= 0x0007;
  375.                 name_type = (int) adapter_data.name_table[i].tbl_name_status;
  376.                 name_type &= 0x0080;
  377.                 name_type = (name_type == 0x0080)? 1 : 0;
  378.                 if (i > 9)
  379.                     {
  380.                     gotoxy(15, 16);
  381.                     cprintf("(Press a key)");
  382.                     bioskey(0);
  383.                     clrscr();
  384.                     j = 2;
  385.                     }
  386.                 gotoxy(1, j++);
  387.                 cprintf("%s  (#%d)  %s  %s",
  388.                     adapter_data.name_table[i].tbl_name,
  389.                     (int) adapter_data.name_table[i].tbl_name_number,
  390.                     name_status_msg [name_status],
  391.                     name_type_msg   [name_type]);
  392.                 }
  393.             }
  394.         else
  395.         if (temp_ncb.NCB_COMMAND == ADD_NAME
  396.           || temp_ncb.NCB_COMMAND == ADD_GROUP_NAME)
  397.             {
  398.             gotoxy(1, 5);
  399.             cprintf("Name number = %d.", (int) temp_ncb.NCB_NUM);
  400.             }
  401.         else
  402.         if (temp_ncb.NCB_COMMAND == CALL)
  403.             {
  404.             gotoxy(1, 5);
  405.             cprintf("Session established.  LSN = %d.", (int) temp_ncb.NCB_LSN);
  406.             }
  407.         else
  408.         if (temp_ncb.NCB_COMMAND == LISTEN)
  409.             {
  410.             gotoxy(1, 5);
  411.             strncpy(string, temp_ncb.NCB_CALLNAME, 16);
  412.             string[16] = '\0';
  413.             cprintf("Session established with '%s'.  LSN = %d.",
  414.                      string, (int) temp_ncb.NCB_LSN);
  415.             }
  416.         else
  417.         if (temp_ncb.NCB_COMMAND == RECEIVE 
  418.           || temp_ncb.NCB_COMMAND == RECEIVE_ANY)
  419.             {
  420.             gotoxy(1, 5);
  421.             cprintf("Message says: ");
  422.             for (i=0, j=6; i<temp_ncb.NCB_LENGTH; i++)
  423.                 {
  424.                 if (i % 60 == 0)
  425.                     gotoxy(1, j++);
  426.                 cprintf("%c", message_in[i]);
  427.                 }
  428.             }
  429.         else
  430.         if (temp_ncb.NCB_COMMAND == SESSION_STATUS)
  431.             {
  432.             gotoxy(1, 4);
  433.             cprintf("Names: %d   sessions: %d",
  434.                 (int) session_info.name_num, (int) session_info.session_count);
  435.             if (session_info.session_count == 0) goto report_exit;
  436.             j = 5;
  437.             for (i=0; i<session_info.session_count; i++)
  438.                 {
  439.                 if (i > 5)
  440.                     {
  441.                     gotoxy(15, 16);
  442.                     cprintf("(Press a key)");
  443.                     bioskey(0);
  444.                     clrscr();
  445.                     j = 5;
  446.                     }
  447.                 gotoxy(1, j++);
  448.                 cprintf("lsn = %d  (%s)  recvcount = %d  sendcount = %d",
  449.                       (int) session_info.session_data[i].lsn,
  450.                       state_msg[(int) session_info.session_data[i].state],
  451.                       (int) session_info.session_data[i].recv_count,
  452.                       (int) session_info.session_data[i].send_count );
  453.                 gotoxy(1, j++);
  454.                 session_info.session_data[i].local_name[15] = '\0';
  455.                 session_info.session_data[i].remote_name[15] = '\0';
  456.                 cprintf("localname = '%s'   remotename = '%s'",
  457.                         session_info.session_data[i].local_name,
  458.                         session_info.session_data[i].remote_name);
  459.                 }
  460.             }
  461.         else
  462.         if (temp_ncb.NCB_COMMAND == HANG_UP)
  463.             {
  464.             gotoxy(1, 5);
  465.             cprintf("Session closed.");
  466.             }
  467.  
  468. report_exit:
  469.         gotoxy(15, 16);
  470.         cprintf("(Press a key)");
  471.         bioskey(0);
  472.         window(1, 1, 80, 25);
  473.         gotoxy(cursor_x, cursor_y);
  474.         puttext(1, 1, 80, 25, screen_save);
  475.         }
  476.  
  477. /* - - - - - - - - - - - - - - - - - - - - - - - */
  478.  
  479. void interrupt     post(void)
  480.         {
  481.         es_reg  = _ES;
  482.         bx_reg  = _BX;
  483.  
  484.         ncb_segments[ncb_head] = es_reg;
  485.         ncb_offsets [ncb_head] = bx_reg;
  486.         ncb_head++;
  487.  
  488.         if (ncb_head == 10)
  489.             ncb_head = 0;
  490.         }
  491.  
  492. /* - - - - - - - - - - - - - - - - - - - - - - - */
  493.  
  494. void    main(int argc, char *argv[])
  495.         {
  496.         int_5C_vector = getvect(0x5C);
  497.         if (int_5C_vector == (void far *) NULL)
  498.             {
  499.             printf("NetBios not loaded (Int5C not present).\n");
  500.             exit(0);
  501.             }
  502.  
  503.         memset(&temp_ncb, 0, sizeof(NCB));
  504.         temp_ncb.NCB_COMMAND = 0x7F;
  505.         NetBios(&temp_ncb);
  506.         if (temp_ncb.NCB_RETCODE != 03)
  507.             {
  508.             printf("NetBios not loaded (No response from Int5C).\n");
  509.             exit(0);
  510.             }
  511.  
  512. show_menu:
  513.         clrscr();
  514.         choice = 0;
  515.  
  516.         printf("NET-TEST Menu:\n\n");
  517.         printf(" 0...exit\n");
  518.         printf(" 1...reset adapter\n");
  519.         printf(" 2...adapter status\n");
  520.         printf(" 3...add name\n");
  521.         printf(" 4...add group name\n");
  522.         printf(" 5...delete name\n");
  523.         printf(" 6...call\n");
  524.         printf(" 7...listen\n");
  525.         printf(" 8...send\n");
  526.         printf(" 9...receive\n");
  527.         printf("10...receive any\n");
  528.         printf("11...hang up\n");
  529.         printf("12...session status\n\n");
  530.         printf("    Choice? ");
  531.  
  532. get_choice:
  533.         if (ncb_head != ncb_tail)
  534.             report_result();
  535.  
  536.         if (!bioskey(1))
  537.             goto get_choice;
  538.  
  539.         gets(string);
  540.         printf("\n");
  541.         if (strlen(string) == 0) goto show_menu;
  542.  
  543.         choice = atoi(string);
  544.         if (choice < 0 || choice > 12) goto show_menu;
  545.  
  546.         switch (choice)
  547.             {
  548.             case 0 :{printf("Exiting.\n"); exit(0);}
  549.             case 1 :{
  550.                     printf("Are you sure (Y/N)? ");
  551.                     gets(string);
  552.                     strlwr(string);
  553.                     if (string[0] != 'y') break;
  554.                     printf("Resetting adapter...\n");
  555.                     memset(&reset_ncb, 0, sizeof(NCB));
  556.                     reset_ncb.NCB_COMMAND = RESET;
  557.                     NetBios(&reset_ncb);
  558.                     printf("Return Code = %d.   (press a key)", 
  559.                         (int) reset_ncb.NCB_RETCODE);
  560.                     bioskey(0);
  561.                     break;
  562.                     }
  563.             case 2 :{
  564.                     printf("GET STATUS -- Enter name of adapter: ");
  565.                     gets(remotename);
  566.                     if (strlen(remotename) == 0) break;
  567.                     expand_to_16_chars(remotename);
  568.                     memset(&adapter_status_ncb, 0, sizeof(NCB));
  569.                     adapter_status_ncb.NCB_COMMAND = STATUS;
  570.                     adapter_status_ncb.POST_FUNC = post;
  571.                     strcpy(adapter_status_ncb.NCB_CALLNAME, remotename);
  572.                     adapter_status_ncb.NCB_BUFFER_PTR = &adapter_data;
  573.                     adapter_status_ncb.NCB_LENGTH  = sizeof(ADAPTER_DATA);
  574.                     memset(&adapter_data, 0, sizeof(ADAPTER_DATA));
  575.                     NetBios(&adapter_status_ncb);
  576.                     break;
  577.                     }
  578.             case 3 :{
  579.                     printf("ADD NAME -- Enter name: ");
  580.                     gets(localname);
  581.                     if (strlen(localname) == 0) break;
  582.                     expand_to_16_chars(localname);
  583.                     memset(&add_name_ncb, 0, sizeof(NCB));
  584.                     add_name_ncb.NCB_COMMAND = ADD_NAME;
  585.                     strcpy(add_name_ncb.NCB_NAME, localname);
  586.                     add_name_ncb.POST_FUNC = post;
  587.                     NetBios(&add_name_ncb);
  588.                     break;
  589.                     }
  590.             case 4 :{
  591.                     printf("ADD GROUP NAME -- Enter name: ");
  592.                     gets(localname);
  593.                     if (strlen(localname) == 0) break;
  594.                     expand_to_16_chars(localname);
  595.                     memset(&add_group_name_ncb, 0, sizeof(NCB));
  596.                     add_group_name_ncb.NCB_COMMAND = ADD_GROUP_NAME;
  597.                     strcpy(add_group_name_ncb.NCB_NAME, localname);
  598.                     add_group_name_ncb.POST_FUNC = post;
  599.                     NetBios(&add_group_name_ncb);
  600.                     break;
  601.                     }
  602.             case 5 :{
  603.                     printf("DELETE NAME -- Enter name: ");
  604.                     gets(localname);
  605.                     if (strlen(localname) == 0) break;
  606.                     expand_to_16_chars(localname);
  607.                     memset(&delete_name_ncb, 0, sizeof(NCB));
  608.                     delete_name_ncb.NCB_COMMAND = DELETE_NAME;
  609.                     strcpy(delete_name_ncb.NCB_NAME, localname);
  610.                     delete_name_ncb.POST_FUNC = post;
  611.                     NetBios(&delete_name_ncb);
  612.                     break;
  613.                     }
  614.             case 6 :{
  615.                     printf("CALL -- Enter remote name to call: ");
  616.                     gets(remotename);
  617.                     if (strlen(remotename) == 0) break;
  618.                     printf("       Enter local (calling) name: ");
  619.                     gets(localname);
  620.                     if (strlen(localname) == 0) break;
  621.                     expand_to_16_chars(remotename);
  622.                     expand_to_16_chars(localname);
  623.                     memset(&call_ncb, 0, sizeof(NCB));
  624.                     call_ncb.NCB_COMMAND = CALL;
  625.                     strcpy(call_ncb.NCB_NAME,     localname);
  626.                     strcpy(call_ncb.NCB_CALLNAME, remotename);
  627.                     call_ncb.NCB_RTO = 0;
  628.                     call_ncb.NCB_STO = 0;
  629.                     call_ncb.POST_FUNC = post;
  630.                     NetBios(&call_ncb);
  631.                     break;
  632.                     }
  633.             case 7 :{
  634.                     printf("LISTEN -- Enter remote name to listen for: ");
  635.                     gets(remotename);
  636.                     if (strlen(remotename) == 0) break;
  637.                     printf("             Enter local (listening) name: ");
  638.                     gets(localname);
  639.                     if (strlen(localname) == 0) break;
  640.                     expand_to_16_chars(remotename);
  641.                     expand_to_16_chars(localname);
  642.                     memset(&listen_ncb, 0, sizeof(NCB));
  643.                     listen_ncb.NCB_COMMAND = LISTEN;
  644.                     strcpy(listen_ncb.NCB_NAME,     localname);
  645.                     strcpy(listen_ncb.NCB_CALLNAME, remotename);
  646.                     listen_ncb.NCB_RTO = 60;
  647.                     listen_ncb.NCB_STO = 0;
  648.                     listen_ncb.POST_FUNC = post;
  649.                     NetBios(&listen_ncb);
  650.                     break;
  651.                     }
  652.             case 8 :{
  653.                     printf("SEND -- Enter message to be sent: ");
  654.                     gets(message_out);
  655.                     if (strlen(message_out) == 0) break;
  656.                     printf("            Enter session number: ");
  657.                     gets(string);
  658.                     if (strlen(string) == 0) break;
  659.                     x = atoi(string);
  660.                     if (x < 1 || x > 254) break;
  661.                     lsn = (unsigned char) x;
  662.                     memset(&send_ncb, 0, sizeof(NCB));
  663.                     send_ncb.NCB_COMMAND = SEND;
  664.                     send_ncb.NCB_LSN     = lsn;
  665.                     send_ncb.NCB_LENGTH  = strlen(message_out) + 1;
  666.                     send_ncb.NCB_BUFFER_PTR  = message_out;
  667.                     send_ncb.POST_FUNC = post;
  668.                     NetBios(&send_ncb);
  669.                     break;
  670.                     }
  671.             case 9 :{
  672.                     printf("RECEIVE -- Enter session number: ");
  673.                     gets(string);
  674.                     if (strlen(string) == 0) break;
  675.                     x = atoi(string);
  676.                     if (x < 1 || x > 254) break;
  677.                     lsn = (unsigned char) x;
  678.                     memset(&receive_ncb, 0, sizeof(NCB));
  679.                     receive_ncb.NCB_COMMAND = RECEIVE;
  680.                     receive_ncb.NCB_LSN     = lsn;
  681.                     receive_ncb.NCB_LENGTH  = MSG_SIZE - 1;
  682.                     receive_ncb.NCB_BUFFER_PTR = message_in;
  683.                     receive_ncb.POST_FUNC = post;
  684.                     NetBios(&receive_ncb);
  685.                     break;
  686.                     }
  687.             case 10:{
  688.                     printf("RECEIVE ANY -- Enter name number: ");
  689.                     gets(string);
  690.                     if (strlen(string) == 0) break;
  691.                     x = atoi(string);
  692.                     if (x < 1 || x > 255) break;
  693.                     name_number = (unsigned char) x;
  694.                     memset(&receive_any_ncb, 0, sizeof(NCB));
  695.                     receive_any_ncb.NCB_COMMAND = RECEIVE_ANY;
  696.                     receive_any_ncb.NCB_NUM     = name_number;
  697.                     receive_any_ncb.NCB_LENGTH  = MSG_SIZE - 1;
  698.                     receive_any_ncb.NCB_BUFFER_PTR = message_in;
  699.                     receive_any_ncb.POST_FUNC = post;
  700.                     NetBios(&receive_any_ncb);
  701.                     break;
  702.                     }
  703.             case 11:{
  704.                     printf("HANG UP -- Enter session number: ");
  705.                     gets(string);
  706.                     if (strlen(string) == 0) break;
  707.                     x = atoi(string);
  708.                     if (x < 1 || x > 254) break;
  709.                     lsn = (unsigned char) x;
  710.                     memset(&hangup_ncb, 0, sizeof(NCB));
  711.                     hangup_ncb.NCB_COMMAND = HANG_UP;
  712.                     hangup_ncb.NCB_LSN     = lsn;
  713.                     hangup_ncb.POST_FUNC   = post;
  714.                     NetBios(&hangup_ncb);
  715.                     break;
  716.                     }
  717.             case 12:{
  718.                     printf("GET SESSION STATUS -- Enter name:");
  719.                     gets(localname);
  720.                     if (strlen(localname) == 0) break;
  721.                     expand_to_16_chars(localname);
  722.                     memset(&session_status_ncb, 0, sizeof(NCB));
  723.                     session_status_ncb.NCB_COMMAND = SESSION_STATUS;
  724.                     strcpy(session_status_ncb.NCB_NAME, localname);
  725.                     session_status_ncb.NCB_LENGTH  = sizeof(STATUS_INFO);
  726.                     session_status_ncb.NCB_BUFFER_PTR = &session_info;
  727.                     session_status_ncb.POST_FUNC = post;
  728.                     NetBios(&session_status_ncb);
  729.                     break;
  730.                     }
  731.             default : break;
  732.             }
  733.  
  734.         goto show_menu;
  735.         }
  736.  
  737. /* - - - - - - - - - - - - - - - - - - - - - - - */
  738.  
  739.  
  740.  
  741.